package LearnDataStructure.a_线性结构.例题;

/**
 * @version: 1.0
 * @Author: wuqiu
 * @date: 2023-07-04 19:34
 * @description: LeetcodeLearnAlgorithm -> LearnDataStructure.a_线性结构.例题
 */

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;

/**有家动物收容所只收留猫和狗，但有特殊的收养规则，收养人有两种收养方式，
 第一种为直接收养所有动物中最早进入收容所的，
 第二种为选择收养的动物类型（猫或狗），并收养该种动物中最早进入收容所的。

 给定一个操作序列int[][2] ope(C++中为vector<vector<int>>)代表所有事件。
 若第一个元素为1，则代表有动物进入收容所，第二个元素为动物的编号，正数代表狗，负数代表猫；
 若第一个元素为2，则代表有人收养动物，第二个元素若为0，则采取第一种收养方式(最早)，
 若为1，则指定收养狗，若为-1则指定收养猫。
 请按顺序返回收养的序列。若出现不合法的操作，即没有可以符合领养要求的动物，则将这次领养操作忽略。
 测试样例：
 [[1,1],[1,-1],[2,0],[2,-1]]

 返回：
 [1,-1]
 */
public class l_猫狗收容和收养 {

    public static void main(String[] args) {
        l_猫狗收容和收养 test = new l_猫狗收容和收养();
        int[][] data = {{1, 1}, {1, -1}, {1, 0}, {1, -5}, {2, 0}, {2, -1}, {2, 0}};
        System.out.println(test.deal(data));
    }

    public ArrayList<Integer> deal(int[][] ope) {
        ArrayList<Integer> result = new ArrayList<Integer>();
        Queue<Animal> cats = new LinkedList<Animal>();
        Queue<Animal> dogs = new LinkedList<Animal>();
        for (int[] element : ope) {
            int key = element[0];
            int value = element[1];
            if (key == 1) {//寄养
                if (value > 0) {//存狗
                    dogs.add(new Animal(value));
                }
                if (value < 0) {//存猫
                    cats.add(new Animal(value));
                }
            } else if (key == 2) {//收养
                if (value == 0) {//收养最早时间的动物
                    if ((!dogs.isEmpty()) && (cats.isEmpty() || dogs.peek().time < cats.peek().time)) {
                        result.add(dogs.poll().type);
                    }
                    if ((!cats.isEmpty()) && (dogs.isEmpty() || cats.peek().time < dogs.peek().time)) {
                        result.add(cats.poll().type);
                    }
                } else {//收养最早时间的单个范围内的
                    if (value == 1 && !dogs.isEmpty()) {
                        result.add(dogs.poll().type);
                    }
                    if (value == -1 && ! cats.isEmpty()) {
                        result.add(cats.poll().type);
                    }
                }
            } else {
                continue;
            }
        }
        return result;
    }

    public static class Animal {
        public int type;
        public int time;
        public static int timeline = 0;

        public Animal(int type) {
            this.type = type;
            this.time = timeline++;
        }
    }


}
